/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated July 28, 2023. Replaces all prior versions.
 *
 * Copyright (c) 2013-2023, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software or
 * otherwise create derivative works of the Spine Runtimes (collectively,
 * "Products"), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
 * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#include <spine/spine-axmol.h>

#include "base/Types.h"
#include "base/Utils.h"
#include <algorithm>
#include <spine/Extension.h>
#include <stddef.h>// offsetof

#include "renderer/backend/DriverBase.h"
#include "renderer/Shaders.h"
#include "xxhash.h"

USING_NS_AX;
#define EVENT_AFTER_DRAW_RESET_POSITION "director_after_draw"
using std::max;
#define INITIAL_SIZE (10000)
#define MAX_VERTICES 64000
#define MAX_INDICES 64000

namespace {

	std::shared_ptr<backend::ProgramState> __twoColorProgramState = nullptr;
	backend::UniformLocation __locPMatrix;
	backend::UniformLocation __locTexture;

	static void updateProgramStateLayout(backend::ProgramState *programState) {
		__locPMatrix = programState->getUniformLocation("u_PMatrix");
		__locTexture = programState->getUniformLocation("u_tex0");

        auto locPosition = programState->getAttributeLocation("a_position");
        auto locTexcoord = programState->getAttributeLocation("a_texCoord");
        auto locColor = programState->getAttributeLocation("a_color");
        auto locColor2 = programState->getAttributeLocation("a_color2");

        auto vertexLayout = programState->getMutableVertexLayout();
        vertexLayout->setAttrib("a_position", locPosition, backend::VertexFormat::FLOAT3,
                                     offsetof(spine::V3F_C4B_C4B_T2F, position), false);
        vertexLayout->setAttrib("a_color", locColor, backend::VertexFormat::UBYTE4,
                                     offsetof(spine::V3F_C4B_C4B_T2F, color), true);
        vertexLayout->setAttrib("a_color2", locColor2, backend::VertexFormat::UBYTE4,
                                     offsetof(spine::V3F_C4B_C4B_T2F, color2), true);
        vertexLayout->setAttrib("a_texCoord", locTexcoord, backend::VertexFormat::FLOAT2,
                                     offsetof(spine::V3F_C4B_C4B_T2F, texCoords), false);
        vertexLayout->setStride(sizeof(spine::V3F_C4B_C4B_T2F));
    }

	static void initTwoColorProgramState() {
		if (__twoColorProgramState) {
			return;
		}
		auto program       = ProgramManager::getInstance()->loadProgram("custom/spineTwoColorTint_vs",
                                                                                      "custom/spineTwoColorTint_fs");
		auto *programState = new backend::ProgramState(program);
		updateProgramStateLayout(programState);

		__twoColorProgramState = std::shared_ptr<backend::ProgramState>(programState);
	}

}// namespace

namespace spine {

	TwoColorTrianglesCommand::TwoColorTrianglesCommand() : _materialID(0), _texture(nullptr), _blendType(BlendFunc::DISABLE) {
		_type = RenderCommand::Type::CUSTOM_COMMAND;
	}

	void TwoColorTrianglesCommand::init(float globalOrder, axmol::Texture2D *texture, axmol::backend::ProgramState *programState, BlendFunc blendType, const TwoColorTriangles &triangles, const Mat4 &mv, uint32_t flags) {

		updateCommandPipelineDescriptor(programState);
		const axmol::Mat4 &projectionMat = Director::getInstance()->getMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_PROJECTION);

		auto finalMatrix = projectionMat * mv;

		_programState->setUniform(_locPMatrix, finalMatrix.m, sizeof(finalMatrix.m));
		_programState->setTexture(_locTexture, 0, texture->getBackendTexture());


		RenderCommand::init(globalOrder, mv, flags);

		_triangles = triangles;
		if (_triangles.indexCount % 3 != 0) {
			int count = _triangles.indexCount;
			_triangles.indexCount = count / 3 * 3;
			AXLOGE("Resize indexCount from {} to {}, size must be multiple times of 3", count, _triangles.indexCount);
		}

		_mv = mv;

		if (_blendType.src != blendType.src || _blendType.dst != blendType.dst ||
			_texture != texture->getBackendTexture() || _pipelineDescriptor.programState != _programState) {
			_texture = texture->getBackendTexture();
			_blendType = blendType;

			_prog = _programState->getProgram();

			auto &blendDescriptor = _pipelineDescriptor.blendDescriptor;
			blendDescriptor.blendEnabled = true;
			blendDescriptor.sourceRGBBlendFactor = blendDescriptor.sourceAlphaBlendFactor = blendType.src;
			blendDescriptor.destinationRGBBlendFactor = blendDescriptor.destinationAlphaBlendFactor = blendType.dst;

			generateMaterialID();
		}
	}


	void TwoColorTrianglesCommand::updateCommandPipelineDescriptor(axmol::backend::ProgramState *programState) {
		// OPTIMIZE ME: all commands belong a same Node should share a same programState like SkeletonBatch
		if (!__twoColorProgramState) {
			initTwoColorProgramState();
		}

		bool needsUpdateStateLayout = false;
		auto &pipelinePS = _pipelineDescriptor.programState;
		if (programState != nullptr) {
			if (_programState != programState) {
				AX_SAFE_RELEASE(_programState);
				_programState = programState;// Because the programState belong to Node, so no need to clone
				AX_SAFE_RETAIN(_programState);
				needsUpdateStateLayout = true;
			}
		} else {
			needsUpdateStateLayout = _programState != nullptr && _programState->getProgram() != __twoColorProgramState->getProgram();
			AX_SAFE_RELEASE(_programState);
			_programState = __twoColorProgramState->clone();
		}

		AXASSERT(_programState, "programState should not be null");
		pipelinePS = _programState;

		if (needsUpdateStateLayout)
			updateProgramStateLayout(pipelinePS);

		_locPMatrix = __locPMatrix;
		_locTexture = __locTexture;
	}

	TwoColorTrianglesCommand::~TwoColorTrianglesCommand() {
		AX_SAFE_RELEASE_NULL(_programState);
	}

	void TwoColorTrianglesCommand::generateMaterialID() {
		// do not batch if using custom uniforms (since we cannot batch) it


		struct
		{
			void *texture;
			void *prog;
			backend::BlendFactor src;
			backend::BlendFactor dst;
		} hashMe;

		// NOTE: Initialize hashMe struct to make the value of padding bytes be filled with zero.
		// It's important since XXH32 below will also consider the padding bytes which probably
		// are set to random values by different compilers.
		memset(&hashMe, 0, sizeof(hashMe));

		hashMe.texture = _texture;
		hashMe.src = _blendType.src;
		hashMe.dst = _blendType.dst;
		hashMe.prog = _prog;
		_materialID = XXH32((const void *) &hashMe, sizeof(hashMe), 0);
	}


	void TwoColorTrianglesCommand::draw(Renderer *r) {
		SkeletonTwoColorBatch::getInstance()->batch(r, this);
	}

	void TwoColorTrianglesCommand::updateVertexAndIndexBuffer(Renderer *r, V3F_C4B_C4B_T2F *vertices, int verticesSize, uint16_t *indices, int indicesSize) {
		if (verticesSize != _vertexCapacity)
			createVertexBuffer(sizeof(V3F_C4B_C4B_T2F), verticesSize, CustomCommand::BufferUsage::DYNAMIC);
		if (indicesSize != _indexCapacity)
			createIndexBuffer(CustomCommand::IndexFormat::U_SHORT, indicesSize, CustomCommand::BufferUsage::DYNAMIC);

		updateVertexBuffer(vertices, sizeof(V3F_C4B_C4B_T2F) * verticesSize);
		updateIndexBuffer(indices, sizeof(uint16_t) * indicesSize);
	}


	static SkeletonTwoColorBatch *instance = nullptr;

	SkeletonTwoColorBatch *SkeletonTwoColorBatch::getInstance() {
		if (!instance) instance = new SkeletonTwoColorBatch();
		return instance;
	}

	void SkeletonTwoColorBatch::destroyInstance() {
		if (instance) {
			delete instance;
			instance = nullptr;
		}
	}

	SkeletonTwoColorBatch::SkeletonTwoColorBatch() : _vertexBuffer(0), _indexBuffer(0) {
		_commandsPool.reserve(INITIAL_SIZE);
		for (unsigned int i = 0; i < INITIAL_SIZE; i++) {
			_commandsPool.push_back(new TwoColorTrianglesCommand());
		}

		reset();

		// callback after drawing is finished so we can clear out the batch state
		// for the next frame
		Director::getInstance()->getEventDispatcher()->addCustomEventListener(EVENT_AFTER_DRAW_RESET_POSITION, [this](EventCustom *eventCustom) {
			this->update(0);
		});
	}

	SkeletonTwoColorBatch::~SkeletonTwoColorBatch() {
		Director::getInstance()->getEventDispatcher()->removeCustomEventListeners(EVENT_AFTER_DRAW_RESET_POSITION);

		for (unsigned int i = 0; i < _commandsPool.size(); i++) {
			delete _commandsPool[i];
			_commandsPool[i] = nullptr;
		}

		delete[] _vertexBuffer;
		delete[] _indexBuffer;
	}

	void SkeletonTwoColorBatch::update(float delta) {
		reset();
	}

	V3F_C4B_C4B_T2F *SkeletonTwoColorBatch::allocateVertices(uint32_t numVertices) {
		if (_vertices.size() - _numVertices < numVertices) {
			V3F_C4B_C4B_T2F *oldData = _vertices.data();
			_vertices.resize((_vertices.size() + numVertices) * 2 + 1);
			V3F_C4B_C4B_T2F *newData = _vertices.data();
			for (uint32_t i = 0; i < this->_nextFreeCommand; i++) {
				TwoColorTrianglesCommand *command = _commandsPool[i];
				TwoColorTriangles &triangles = (TwoColorTriangles &) command->getTriangles();
				triangles.verts = newData + (triangles.verts - oldData);
			}
		}

		V3F_C4B_C4B_T2F *vertices = _vertices.data() + _numVertices;
		_numVertices += numVertices;
		return vertices;
	}


	void SkeletonTwoColorBatch::deallocateVertices(uint32_t numVertices) {
		_numVertices -= numVertices;
	}


	unsigned short *SkeletonTwoColorBatch::allocateIndices(uint32_t numIndices) {
		if (_indices.getCapacity() - _indices.size() < numIndices) {
			unsigned short *oldData = _indices.buffer();
			int oldSize = (int)_indices.size();
			_indices.ensureCapacity(_indices.size() + numIndices);
			unsigned short *newData = _indices.buffer();
			for (uint32_t i = 0; i < this->_nextFreeCommand; i++) {
				TwoColorTrianglesCommand *command = _commandsPool[i];
				TwoColorTriangles &triangles = (TwoColorTriangles &) command->getTriangles();
				if (triangles.indices >= oldData && triangles.indices < oldData + oldSize) {
					triangles.indices = newData + (triangles.indices - oldData);
				}
			}
		}

		unsigned short *indices = _indices.buffer() + _indices.size();
		_indices.setSize(_indices.size() + numIndices, 0);
		return indices;
	}

	void SkeletonTwoColorBatch::deallocateIndices(uint32_t numIndices) {
		_indices.setSize(_indices.size() - numIndices, 0);
	}

	TwoColorTrianglesCommand *SkeletonTwoColorBatch::addCommand(axmol::Renderer *renderer, float globalOrder, axmol::Texture2D *texture, backend::ProgramState *programState, axmol::BlendFunc blendType, const TwoColorTriangles &triangles, const axmol::Mat4 &mv, uint32_t flags) {
		TwoColorTrianglesCommand *command = nextFreeCommand();
		command->init(globalOrder, texture, programState, blendType, triangles, mv, flags);
		command->updateVertexAndIndexBuffer(renderer, triangles.verts, triangles.vertCount, triangles.indices, triangles.indexCount);
		renderer->addCommand(command);
		return command;
	}

	void SkeletonTwoColorBatch::batch(axmol::Renderer *renderer, TwoColorTrianglesCommand *command) {
		if (_numVerticesBuffer + command->getTriangles().vertCount >= MAX_VERTICES || _numIndicesBuffer + command->getTriangles().indexCount >= MAX_INDICES) {
			flush(renderer, _lastCommand);
		}

		uint32_t materialID = command->getMaterialID();
		if (_lastCommand && _lastCommand->getMaterialID() != materialID) {
			flush(renderer, _lastCommand);
		}

		memcpy(_vertexBuffer + _numVerticesBuffer, command->getTriangles().verts, sizeof(V3F_C4B_C4B_T2F) * command->getTriangles().vertCount);
		const Mat4 &modelView = command->getModelView();
		for (int i = _numVerticesBuffer; i < _numVerticesBuffer + command->getTriangles().vertCount; i++) {
			modelView.transformPoint(&_vertexBuffer[i].position);
		}

		unsigned short vertexOffset = (unsigned short) _numVerticesBuffer;
		unsigned short *indices = command->getTriangles().indices;
		for (int i = 0, j = _numIndicesBuffer; i < command->getTriangles().indexCount; i++, j++) {
			_indexBuffer[j] = indices[i] + vertexOffset;
		}

		_numVerticesBuffer += command->getTriangles().vertCount;
		_numIndicesBuffer += command->getTriangles().indexCount;

		if (command->isForceFlush()) {
			flush(renderer, command);
		}
		_lastCommand = command;
	}

	void SkeletonTwoColorBatch::flush(axmol::Renderer *renderer, TwoColorTrianglesCommand *materialCommand) {
		if (!materialCommand)
			return;

		materialCommand->updateVertexAndIndexBuffer(renderer, _vertexBuffer, _numVerticesBuffer, _indexBuffer, _numIndicesBuffer);

		renderer->addCommand(materialCommand);

		_numVerticesBuffer = 0;
		_numIndicesBuffer = 0;
		_numBatches++;
	}

	void SkeletonTwoColorBatch::reset() {
		_nextFreeCommand = 0;
		_numVertices = 0;
		_indices.setSize(0, 0);
		_numVerticesBuffer = 0;
		_numIndicesBuffer = 0;
		_lastCommand = nullptr;
		_numBatches = 0;
	}

	TwoColorTrianglesCommand *SkeletonTwoColorBatch::nextFreeCommand() {
		if (_commandsPool.size() <= _nextFreeCommand) {
			unsigned int newSize = (int)_commandsPool.size() * 2 + 1;
			for (int i = (int)_commandsPool.size(); i < newSize; i++) {
				_commandsPool.push_back(new TwoColorTrianglesCommand());
			}
		}
		TwoColorTrianglesCommand *command = _commandsPool[_nextFreeCommand++];
		command->setForceFlush(false);
		return command;
	}
}// namespace spine
